/**
 * 购物车管理服务模块
 *
 * 处理购物车相关的数据操作逻辑
 */
const { Cart, Goods } = require('../models');
const { Op } = require('sequelize');
const CustomError = require('../utils/customError');
const logger = require('../utils/logger');

class CartService {
  /**
   * 添加商品到购物车或更新购物车商品数量
   * @param {number} userId 用户ID
   * @param {number} goodsId 商品ID
   * @param {number} count 购买数量（可以是正数或负数，正数表示增加，负数表示减少）
   * @param {string} blessing 祝福语（可选）
   * @returns {Promise<Object>}
   */
  static async addToCart(userId, goodsId, count, blessing = '') {
    try {
      logger.debug(`服务层添加商品到购物车: userId=${userId}, goodsId=${goodsId}, count=${count}, blessing=${blessing}`);

      // 检查商品是否存在且上架
      const goods = await Goods.findOne({
        where: {
          id: goodsId,
          onSale: 1
        }
      });

      if (!goods) {
        logger.warn(`商品不存在或已下架: goodsId=${goodsId}`);
        throw new CustomError(404, '商品不存在或已下架');
      }

      logger.debug(`找到商品:`, goods.toJSON());

      // 查找购物车中是否已存在该商品
      let cartItem = await Cart.findOne({
        where: {
          userId,
          goodsId
        }
      });

      if (cartItem) {
        logger.debug(`购物车中已存在该商品:`, cartItem.toJSON());
        // 已存在，更新数量
        const newQuantity = cartItem.quantity + count;
        
        if (newQuantity <= 0) {
          // 数量为0或负数，删除该商品
          await cartItem.destroy();
          return {
            cartId: cartItem.id,
            goodsId,
            count: 0,
            checked: 0
          };
        }
        
        // 更新数量和祝福语
        cartItem.quantity = newQuantity;
        if (blessing) {
          cartItem.blessing = blessing;
        }
        await cartItem.save();
        
        return {
          cartId: cartItem.id,
          goodsId,
          count: cartItem.quantity,
          checked: cartItem.checked
        };
      } else {
        // 不存在，添加新商品到购物车
        if (count <= 0) {
          logger.warn(`添加数量必须大于0: count=${count}`);
          throw new CustomError(400, '添加数量必须大于0');
        }
        
        logger.debug(`创建新的购物车项`);
        const newCartItem = await Cart.create({
          userId,
          goodsId,
          quantity: count,
          blessing: blessing || '',
          checked: 1
        });
        
        logger.debug(`新购物车项创建成功:`, newCartItem.toJSON());
        
        return {
          cartId: newCartItem.id,
          goodsId,
          count: newCartItem.quantity,
          checked: newCartItem.checked
        };
      }
    } catch (error) {
      logger.error('添加商品到购物车服务层出错:', error);
      // 如果是外键约束错误，则抛出自定义错误
      if (error.name === 'SequelizeForeignKeyConstraintError') {
        throw new CustomError(400, '无效的用户ID或商品ID');
      }
      throw error;
    }
  }

  /**
   * 获取购物车列表
   * @param {number} userId 用户ID
   * @returns {Promise<Array>}
   */
  static async getCartList(userId) {
    try {
      logger.debug(`获取购物车列表: userId=${userId}`);
      const result = await Cart.findAll({
        where: {
          userId
        },
        include: [
          {
            model: Goods,
            as: 'goods',
            attributes: ['id', 'name', 'price', 'marketPrice', 'mainImgUrl', 'stock']
          }
        ],
        order: [['updated_at', 'DESC']]
      });
      
      logger.debug(`获取购物车列表成功，共${result.length}项`);
      return result;
    } catch (error) {
      logger.error('获取购物车列表服务层出错:', error);
      throw error;
    }
  }

  /**
   * 更新购物车中商品的选中状态
   * @param {number} userId 用户ID
   * @param {number} goodsId 商品ID
   * @param {number} checked 选中状态（0-取消勾选，1-勾选）
   * @returns {Promise<Object>}
   */
  static async checkCart(userId, goodsId, checked) {
    try {
      logger.debug(`更新购物车商品选中状态: userId=${userId}, goodsId=${goodsId}, checked=${checked}`);
      const result = await Cart.update(
        { checked: checked ? 1 : 0 },
        {
          where: {
            userId,
            goodsId
          }
        }
      );

      if (result[0] === 0) {
        logger.warn(`购物车商品不存在: userId=${userId}, goodsId=${goodsId}`);
        throw new CustomError(404, '购物车商品不存在');
      }

      logger.debug(`更新购物车商品选中状态成功`);
      return {
        goodsId,
        checked: checked ? 1 : 0
      };
    } catch (error) {
      logger.error('更新购物车商品选中状态服务层出错:', error);
      throw error;
    }
  }

  /**
   * 实现购物车商品的全选和全不选功能
   * @param {number} userId 用户ID
   * @param {number} checked 全选状态（0-取消全选，1-全选）
   * @returns {Promise<Object>}
   */
  static async checkAllCart(userId, checked) {
    try {
      logger.debug(`全选/全不选购物车商品: userId=${userId}, checked=${checked}`);
      const result = await Cart.update(
        { checked: checked ? 1 : 0 },
        {
          where: {
            userId
          }
        }
      );

      logger.debug(`全选/全不选购物车商品成功，更新了${result[0]}项`);
      return {
        updatedCount: result[0]
      };
    } catch (error) {
      logger.error('全选/全不选购物车商品服务层出错:', error);
      throw error;
    }
  }

  /**
   * 删除购物车中的指定商品
   * @param {number} userId 用户ID
   * @param {number} goodsId 商品ID
   * @returns {Promise<Object>}
   */
  static async deleteCartItem(userId, goodsId) {
    try {
      logger.debug(`删除购物车商品: userId=${userId}, goodsId=${goodsId}`);
      const result = await Cart.destroy({
        where: {
          userId,
          goodsId
        }
      });

      logger.debug(`删除购物车商品成功，删除了${result}项`);
      return {
        deletedCount: result
      };
    } catch (error) {
      logger.error('删除购物车商品服务层出错:', error);
      throw error;
    }
  }
}

module.exports = CartService;